Aminet 1 (Walnut Creek)/Aminet - June 1993 [Walnut Creek].iso/usenet/sources/volume89/aplictns/graph.7

Internet Message Format | 1989-11-13 | 58KB

Path: xanth!lll-winken!ctrsol!gem.mps.ohio-state.edu!brutus.cs.uiuc.edu!wuarchive!texbell!texsun!newstop!sun!swap!page
From: [e-mail] (Bob Page)
Newsgroups: comp.sources.amiga
Subject: v89i210:  graph - plot mathematical functions, Part07/07
Message-ID: <[e-mail]>
Date: 13 Nov 89 02:33:00 GMT
Sender: [e-mail]
Lines: 1795
Approved: [e-mail]

Submitted-by: [e-mail] (David Gay)
Posting-number: Volume 89, Issue 210
Archive-name: applications/graph.7

# This is a shell archive.
# Remove anything above and including the cut line.
# Then run the rest of the file through 'sh'.
# Unpacked files will be owned by you and have default permissions.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar: SHell ARchive
# Run the following text through 'sh' to create:
#    uio.c
#    uio.h
#    x_y.c
# This is archive 7 of a 7-part kit.
# This archive created: Sun Nov 12 18:23:32 1989
echo "extracting uio.c"
sed 's/^X//' << \SHAR_EOF > uio.c
X/*
X *                 GRAPH, Version 1.00 - 4 August 1989
X *
X *            Copyright 1989, David Gay. All Rights Reserved.
X *            This software is freely redistrubatable.
X */
X
X/* User interface routines */
X
X#include <exec/types.h>
X#include <exec/interrupts.h>
X#include <exec/ports.h>
X#include <exec/io.h>
X#include <exec/interrupts.h>
X#include <devices/input.h>
X#include <devices/inputevent.h>
X#define INTUITIONPRIVATE
X#include <intuition/intuitionbase.h>
X#include <intuition/intuition.h>
X#include <graphics/text.h>
X#include <libraries/diskfont.h>
X#include "libraries/arpbase.h"
X#include <math.h>
X#include <stdio.h>
X#include <string.h>
X#include <assert.h>
X#include <dos.h>
X#include <stdarg.h>
X#include <ctype.h>
X
X#include "uio.h"
X#include "graph.h"
X#include "grph.h"
X#include "list.h"
X#include "object.h"
X#include "user/gadgets.h"
X#include "tracker.h"
X
X#include <proto/exec.h>
X#include <proto/intuition.h>
X#include <proto/graphics.h>
X#include <proto/diskfont.h>
X#define NODOS
X#include "proto/arp.h"
X
X#define DEFAVAILSIZE 2048 /* Default space reserved for AvailFonts */
X#define ARROW 42 /* Identifier of arrow gadget */
X#define CROSS 666 /* Identifer of cross gadget */
X
Xstruct fnode /* font node */
X{
X    tnode node;
X    char name[FONTLEN];
X};
X
Xtlist flist;
X
Xextern struct IntuitionBase *IntuitionBase;
X
X/* Default graph window */
Xstatic struct NewWindow graph_win = {
X    0, 0,
X    640, 200,
X    -1, -1,
X    RAWKEY | REFRESHWINDOW | CLOSEWINDOW | MENUPICK | GADGETDOWN | GADGETUP | R
XEQCLEAR | REQSET | MOUSEBUTTONS | MOUSEMOVE,
X    WINDOWSIZING | WINDOWDRAG | WINDOWDEPTH | WINDOWCLOSE | SIMPLE_REFRESH | AC
XTIVATE,
X    NULL,
X    NULL,
X    "Graph",
X    NULL,
X    NULL,
X    85, 60,
X    -1, -1,
X    WBENCHSCREEN
X};
X
X/* The two icon images */
Xstatic UWORD chip arrow_data[] = {
X    0x7fff, 0x7fff, 0x601f, 0x603f, 0x607f, 0x607f, 0x603f, 0x661f, 0x6f0f, 0x7
Xf87, 0x7fc3, 0x7fe3, 0x7fff,
X    0x0000, 0x0000, 0x1fe0, 0x1fc0, 0x1f80, 0x1f80, 0x1fc0, 0x19e0, 0x10f0, 0x0
X078, 0x003c, 0x001c, 0x0000
X};
X
Xstatic struct Image arrow_image = {
X    -1, 0, 16, 13, 2,
X    arrow_data,
X    3, 0
X};
X
Xstatic struct Gadget arrow = {
X    NULL,
X    -18, 18, 15, 13,
X    GADGHCOMP | GADGIMAGE | GRELRIGHT,
X    RELVERIFY | RIGHTBORDER | TOGGLESELECT,
X    BOOLGADGET,
X    (APTR)&arrow_image, NULL, NULL,
X    2,
X    NULL,
X    ARROW
X};
X
Xstatic UWORD chip cross_data[] = {
X    0x7fff, 0x7f7f, 0x7f7f, 0x7f7f, 0x7f7f, 0x7e3f, 0x4081, 0x7e3f, 0x7f7f, 0x7
Xf7f, 0x7f7f, 0x7f7f, 0x7fff,
X    0x0000, 0x0080, 0x0080, 0x0080, 0x0080, 0x01c0, 0x3f7e, 0x01c0, 0x0080, 0x0
X080, 0x0080, 0x0080, 0x0000
X};
X
Xstatic struct Image cross_image = {
X    -1, 0, 16, 13, 2,
X    cross_data,
X    3, 0
X};
X
Xstatic struct Gadget cross = {
X    NULL,
X    -18, 36, 15, 13,
X    GADGHCOMP | GADGIMAGE | GRELRIGHT | SELECTED,
X    RELVERIFY | RIGHTBORDER | TOGGLESELECT,
X    BOOLGADGET,
X    (APTR)&cross_image, NULL, NULL,
X    1,
X    NULL,
X    CROSS
X};
X
Xstatic struct Memory *abort_mem; /* for abort requester */
X
Xstatic struct TextAttr alert_attr = { "topaz.font", 8 };
Xstatic struct TextFont *alert_font;
X
Xstatic struct Task *me;
Xstatic struct MsgPort *inputDevPort; /* for input device */
Xstatic struct IOStdReq *inputRequestBlock;
Xstatic struct Interrupt handlerStuff;
Xstatic int inputOpen;
X
Xstatic long window_sigs;  /* Combined sigs of all windows */
X
Xstatic struct TextAttr font = { "topaz.font", 8 }; /* font for menus, requester
Xs, etc */
Xstatic struct Requester *req;    /* Current requester */
Xstatic int ok;                   /* Value of last GadgetID */
Xstatic short reqdone;            /* Req must go away. Don't activate next str g
Xadget */
Xstatic gadgevent *gadgethandler; /* Handler for gadget events */
X
X/* Add .font extension to fname (assumed of size FONTLEN) */
Xchar *addfont(char *fname)
X{
X    return strncat(fname, ".font", FONTLEN - 1 - strlen(fname));
X}
X
X/* Removes .font extension if present */
Xchar *remfont(char *fname)
X{
X    int l = strlen(fname);
X
X    if (l >= 5 && strcmp(&fname[l - 5], ".font") == 0) fname[l - 5] = '\0';
X
X    return fname;
X}
X
X/* Make a list of font names, one entry per font. Sizes, etc ignored. */
Xint make_font_list(void)
X{
X    int ok = FALSE;
X    char *abuf;
X
X    new_list(&flist);
X    if (abuf = AllocMem(DEFAVAILSIZE, 0L)) /* Alloc default avail buffer */
X    {
X        int needs = AvailFonts(abuf, DEFAVAILSIZE, AFF_MEMORY | AFF_DISK);
X
X        ok = TRUE;
X        if (needs != 0) /* Need a bigger buffer */
X        {
X            FreeMem(abuf, DEFAVAILSIZE);
X            if (abuf = AllocMem(DEFAVAILSIZE + needs, 0L))
X                if (AvailFonts(abuf, DEFAVAILSIZE + needs, AFF_MEMORY | AFF_DIS
XK))
X                    ok = FALSE; /* Definite failure */
X        }
X        if (ok) /* Construct font list */
X        {
X            struct AvailFontsHeader *hdr = (struct AvailFontsHeader *)abuf;
X            struct AvailFonts *fl = (struct AvailFonts *)(hdr + 1);
X            int i;
X
X            /* Add font entries to sorted list, by name. Duplicate entries remo
Xved */
X            for (i = hdr->afh_NumEntries; i > 0; i--, fl++)
X            {
X                struct fnode *scan;
X                char *name = fl->af_Attr.ta_Name;
X                int cmp = -1;
X
X                remfont(name); /* remove extension */
X
X                /* Find insertion position */
X                for (scan = first(&flist); succ(scan) && (cmp = strcmp(name, sc
Xan->name)) > 0; scan = succ(scan))
X                    ;
X                if (cmp != 0) /* Not already present, add to list */
X                {
X                    struct fnode *n = alloc_node(sizeof(struct fnode));
X
X                    if (!n)
X                    {
X                        ok = FALSE;
X                        break;
X                    }
X                    n->node.ln_Name = n->name;
X                    n->name[FONTLEN - 1] = '\0';
X                    strncpy(n->name, name, FONTLEN - 1);
X
X                    /* Add at correct position */
X                    insert(&flist, n, scan->node.ln_Pred);
X                }
X            }
X            if (!ok)
X            {
X                free_list((list *)&flist, sizeof(struct fnode));
X                new_list(&flist);
X            }
X        }
X        FreeMem(abuf, DEFAVAILSIZE + needs);
X    }
X    if (!ok) nomem(NULL);
X    return ok;
X}
X
X
X/* Implement mutual exclude seeing Intuition is lazy */
X/* (for border gadgets)                              */
X/* ------------------------------------------------- */
Xstatic void MutualExclude(struct Gadget *us, struct Gadget *gadg, struct Window
X *win)
X{
X    register int i;
X    register struct Gadget *gp;
X    register LONG mutex = us->MutualExclude;
X    UWORD pos;
X
X    /* scan gadget list */
X    for (i = 1, gp = gadg; gp && i != 0; i <<= 1, gp = gp->NextGadget)
X        if (i & mutex)
X        {
X            pos = RemoveGadget(win, gp);
X            gp->Flags &= ~SELECTED; /* unselect */
X            AddGadget(win, gp, pos);
X        }
X    pos = RemoveGadget(win, us);
X    us->Flags |= SELECTED;
X    AddGadget(win, us, pos);
X
X    RefreshWindowFrame(win); /* This works for border gadgets */
X}
X
X/* Implement mutual exclude seeing Intuition is lazy */
X/* (for requester gadgets)                           */
Xstatic void MutEx(struct Gadget *us, struct Requester *req)
X{
X    register int nb = 0, doneus = FALSE;
X    register struct Gadget *gp, *first = NULL;
X    register LONG mutex = us->MutualExclude;
X    UWORD pos;
X
X    /* scan gadget list */
X    for (gp = req->ReqGadget; gp && (mutex != 0 || !doneus); mutex >>= 1, gp =
Xgp->NextGadget)
X    {
X        if ((mutex & 1) || (doneus = gp == us))
X        {
X            if (!first) first = gp;
X            pos = RemoveGList(req->RWindow, gp, 1);
X            if (gp == us)
X                gp->Flags |= SELECTED;  /* select */
X            else
X                gp->Flags &= ~SELECTED; /* unselect */
X            AddGList(req->RWindow, gp, pos, 1, req);
X        }
X        if (first) nb++;
X    }
X    if (first) RefreshGList(first, req->RWindow, req, nb);
X}
X
X/* Display requester, & handle everything until it goes away */
Xint DoRequest(struct Requester *r, struct graph *g, gadgevent *handle)
X{
X    r->Flags |= NOISYREQ; /* We want keystrokes */
X
X    ok = FALSE;
X    if (Request(r, g->io.win))
X    {
X        /* setup vital info */
X        gadgethandler = handle;
X        req = r;
X        reqdone = FALSE;
X        while (next_command().command != reqgone) ; /* Wait till it leaves */
X        req = NULL; /* No req. present */
X        gadgethandler = NULL;
X    }
X    return ok;
X}
X
X/* Find first string gadget */
Xstatic struct Gadget *NextText(struct Gadget *look)
X{
X    while (look && (look->GadgetType & ~GADGETTYPE) != STRGADGET) look = look->
XNextGadget;
X    return look;
X}
X
X/* Default gadget handler, activates string gadgets in sequence & handles
X   mutual exclude. Will normally be called by custom handlers if they don't
X   have anything special to do.
X   Returens the new value of ok */
Xint std_ghandler(struct Gadget *gg, ULONG class, struct Requester *req, struct
Xgraph *g)
X{
X    if ((gg->GadgetType & ~GADGETTYPE) == STRGADGET && !reqdone) /* Activate ne
Xxt one */
X    {
X        struct Gadget *ng = NextText(gg->NextGadget);
X        if (!ng) ng = NextText(req->ReqGadget);
X        if (ng) ActivateGadget(ng, req->RWindow, req);
X    }
X    else if (gg->MutualExclude != 0) MutEx(gg, req);
X
X    return gg->GadgetID != 0;
X}
X
X/* Insert ins in front of into, checking for string overflow
X   ( sizeof(into)=maxlen ) */
Xstatic char *strinsert(char *into, char *ins, int maxlen)
X{
X    int delta = strlen(ins);
X    int start = strlen(into);
X    int i;
X
X    if (start + delta >= maxlen) start = maxlen - delta - 1;
X
X    for (i = start - 1; i >= 0; i--) into[i + delta] = into[i];
X    into[start + delta] = '\0';
X    memcpy(into, ins, delta);
X
X    return into;
X}
X
X/* Convert a lock to a path, store in to (maxlen chars long) */
Xstatic char *pathstr(char *to, long l, int maxlen)
X{
X    long tl;
X    int notfirst = FALSE;
X    struct FileInfoBlock *fib = (struct FileInfoBlock *)AllocMem(sizeof(struct
XFileInfoBlock), 0);
X
X    if (!fib) return(NULL);
X    to[0] = '\0';
X
X    do {
X        if (!Examine(l, fib))
X        {
X            to = NULL;
X            goto error;
X        }
X        if (fib->fib_DirEntryType > 0) strinsert(to, "/", maxlen);
X        /* Is this still necessary ? */
X        if (fib->fib_FileName[0] == '\0') strinsert(to, "RAM", maxlen);
X        else strinsert(to, fib->fib_FileName, maxlen);
X        tl = l;
X        l = ParentDir(l);
X        if (notfirst) UnLock(tl); /* Release allocated locks */
X        notfirst = TRUE;
X    } while (l);
X
X    *(strchr(to, '/')) = ':'; /* First name is disk name */
X
Xerror:
X    FreeMem((char *)fib, sizeof(struct FileInfoBlock));
X    return(to);
X}
X
X/* Request a file from the user (save in file), return TRUE if OK,
X   FALSE if cancelled or failed. Currently uses arp file requester. */
Xint getfile(char *file, char *msg)
X{
X    static char directory[DSIZE + 1];
X    static struct FileRequester FR;
X    char filename[FCHARS + 1];
X
X    filename[0] = '\0';
X    FR.fr_Hail = msg;
X    FR.fr_File = filename;
X    FR.fr_Dir = directory;
X
X    if (FileRequest(&FR))
X    {
X        long lock = Lock(directory, SHARED_LOCK);
X
X        if (lock)
X        {
X            if (!pathstr(file, lock, FILELEN)) /* get dir path */
X            {
X                UnLock(lock);
X                return FALSE;
X            }
X            strncat(file, filename, FILELEN - 1 - strlen(file));
X
X            UnLock(lock);
X            return TRUE;
X        }
X        else
X            alert(NULL, "Failed to lock directory", directory);
X    }
X    return FALSE;
X}
X
X/* Setup an "abort" requester, in graph g with text msg (must be as long as max
X message) */
Xstruct Requester *abort_request(struct graph *g, char *msg)
X{
X    int len = strlen(msg);
X    struct Requester *req;
X    struct Gadget *gl = NULL;
X    int height, width;
X    static struct Gadget text = {
X        NULL,
X        10, 10, 1, 1,
X        GADGHNONE, 0L, BOOLGADGET | REQGADGET
X    };
X
X    /* Construct requester */
X    height = 8 * 1 + 10 + 12 + 25;
X    width = 8 * len + 2 * 10;
X    if (width < 85) width = 85;
X
X    text.GadgetText = NULL;
X    if ((abort_mem = NewMemory()) &&
X        (req = InitReq(50, 15, width, height, abort_mem)) &&
X        SetReqBorder(req, 1, abort_mem) &&
X        AddBox(&gl, TRUE, "Stop!", 0, RELVERIFY, (width - 65) / 2, height - 25,
X 65, 15, FALSE, abort_mem) &&
X        AddIntuiText(&text.GadgetText, msg, 0, 0, abort_mem))
X    {
X        SetReqGadgets(req, gl);
X        text.NextGadget = req->ReqGadget;
X        req->ReqGadget = &text;
X        if (!Request(req, g->io.win)) req = NULL; /* display req */
X    }
X    else
X        req = NULL;
X
X    if (!req) Free(abort_mem);
X
X    return req;
X}
X
X/* Change abort requester message. msg must not be longer than the first msg */
X
Xvoid set_abort_msg(struct Requester *req, char *msg)
X{
X    req->ReqGadget->GadgetText->IText = msg;
X    RefreshGList(req->ReqGadget, req->RWindow, req, 1);
X}
X
X/* Clear abort requester */
Xvoid end_abort_request(struct Requester *req)
X{
X    EndRequest(req, req->RWindow);
X    Free(abort_mem);
X}
X
X/* Has the user asked for an abort ? */
Xint aborted(struct Requester *req)
X{
X    int abort = FALSE;
X    struct IntuiMessage *msg;
X
X    while (msg = (struct IntuiMessage *)GetMsg(req->RWindow->UserPort))
X    {
X        ULONG class = msg->Class;
X
X        ReplyMsg((struct Message *)msg);
X
X        if (class == REFRESHWINDOW) /* Ignore refreshes at this time */
X        {
X            BeginRefresh(req->RWindow);
X            EndRefresh(req->RWindow, TRUE);
X        }
X        else if (class == GADGETUP) abort = TRUE;
X    }
X    return abort;
X}
X
X/* Display a message in graph g. You pass as many string as you want, followed
X   by (char *)NULL. This will try very hard to actually display it, calling
X   alert with the first two strings if it fails. */
Xvoid message(struct graph *g, ...)
X{
X    int nb, len;
X    va_list msgs;
X    char *scan;
X    struct Memory *m;
X    struct Requester *req;
X    struct Gadget *gl = NULL;
X    int height, width;
X    int ok = FALSE;
X
X    /* Find number of lines and maxmimum length */
X    nb = 0; len = 0;
X    va_start(msgs, g);
X    while (scan = va_arg(msgs, char *))
X    {
X        int nl = strlen(scan);
X
X        nb++;
X        if (nl > len) len = nl;
X    }
X    va_end(msgs);
X
X    /* Construct requester */
X    height = 8 * nb + 10 + 12 + 25;
X    width = 8 * len + 2 * 10;
X    if (width < 85) width = 85;
X
X    if ((m = NewMemory()) &&
X        (req = InitReq(50, 15, width, height, m)) &&
X        SetReqBorder(req, 1, m) &&
X        AddBox(&gl, TRUE, "Ok", 0, RELVERIFY | ENDGADGET, (width - 65) / 2, hei
Xght - 25, 65, 15, FALSE, m))
X    {
X        int y = 10 - 8;
X
X        ok = TRUE;
X        SetReqGadgets(req, gl);
X
X        /* Add message strings */
X        va_start(msgs, g);
X        while (ok && (scan = va_arg(msgs, char *)))
X            ok = ok && AddIntuiText(&req->ReqText, scan, 10, (y += 8), m);
X        va_end(msgs);
X
X        /* You'll have a surprise if you press Amiga-B ... */
X        if (ok && g) ok = DoRequest(req, g, std_ghandler);
X    }
X    Free(m);
X    if (!ok || !g) /* call alert */
X    {
X        va_start(msgs, g);
X        if (nb == 1)
X            alert(g ? g->io.win : NULL, va_arg(msgs, char *), NULL);
X        else if (nb >= 2)
X        {
X            char *m1 = va_arg(msgs, char *);
X            char *m2 = va_arg(msgs, char *);
X
X            alert(g ? g->io.win : NULL, m1, m2);
X        }
X    }
X}
X
X/* Display a two line auto request. Doesn't alloc any resources */
Xvoid alert(struct Window *win, char *msg1, char *msg2)
X{
X    struct IntuiText text1, text2, negative;
X    const static struct IntuiText template = {
X        0, 1, JAM1,
X        8, 0,
X        &alert_attr
X    };
X    int width, height;
X    int ysize = alert_font ? alert_font->tf_YSize : 8;
X
X    text1 = text2 = negative = template;
X    text1.TopEdge = 8;
X    text1.IText = msg1;
X    width = IntuiTextLength(&text1) + 20;
X    height = 37 + 2 * ysize;
X    if (msg2 != NULL)
X    {
X        int w;
X
X        text1.NextText = &text2;
X        text2.TopEdge = text1.TopEdge + ysize;
X        text2.IText = msg2;
X
X        height += ysize;
X        w = IntuiTextLength(&text2) + 20;
X        if (w > width) width = w;
X    }
X    negative.LeftEdge = 6;
X    negative.TopEdge = 4;
X    negative.IText = "Ok";
X
X    AutoRequest(win, &text1, NULL, &negative, 0L, 0L, width, height);
X}
X
X/* Easy no mem requester */
Xvoid nomem(struct Window *win)
X{
X    alert(win, "No memory !", NULL);
X}
X
X/* Return next menu selection that is a command (in graph g).
X   *choice is the item number of the next menu selection */
Xstatic struct cmd process(UWORD *choice, struct graph *g)
X{
X    struct MenuItem *item;
X    UWORD itemnb, subnb;
X    struct cmd cmd;
X    struct pos *rect = (struct pos *)g->s.current;
X
X    /* Prepare command */
X    cmd.command = none;
X    cmd.g = g;
X
X    /* Try & find a command */
X    while (cmd.command == none && *choice != MENUNULL)
X    {
X        item = ItemAddress(g->io.menu, *choice);
X        itemnb = ITEMNUM(*choice);
X        subnb = SUBNUM(*choice);
X
X        /* Rem: illegal choices are disabled ==> no checking here */
X        switch (MENUNUM(*choice)) {
X            case 0 : switch (itemnb) { /* Project */
X                case 0 : /* New Graph */
X                    cmd.command = _new_graph;
X                    break;
X                case 1 : /* Delete Graph */
X                    cmd.command = close;
X                    break;
X                case 2 : /* Load Graph */
X                    cmd.command = _load_graph;
X                    break;
X                case 3 : /* Save Graph */
X                    cmd.command = _save_graph;
X                    break;
X                case 4 : /* Output Graph */
X                    switch (subnb)
X                    {
X                        case 0 : /* To Printer */
X                            cmd.command = print_graph;
X                            break;
X                        case 1 : /* To Disk */
X                            cmd.command = iff_graph;
X                            break;
X                    }
X                    break;
X                case 6 : /* Load Variables */
X                    cmd.command = load_vars;
X                    break;
X                case 7 : /* Save Variables */
X                    cmd.command = save_vars;
X                    break;
X                case 9 : /* Quit */
X                    cmd.command = quit;
X                    break;
X                } break;
X
X            case 1 : switch (itemnb) { /* Graph */
X                case 0 : /* Scale */
X                    deselect(g);
X                    cmd.command = limits;
X                    break;
X                case 1 : /* Axes */
X                    deselect(g);
X                    cmd.command = axes;
X                    break;
X                case 2 : /* Zoom */
X                    cmd.command = zoom;
X                    cmd.data.zoom_in.x0 = rect->x0;
X                    cmd.data.zoom_in.y0 = rect->y0;
X                    cmd.data.zoom_in.x1 = rect->x1;
X                    cmd.data.zoom_in.y1 = rect->y1;
X                    deselect(g);
X                    break;
X                case 3 : /* Zoom Out */
X                    cmd.command = zoom_out;
X                    cmd.data.zoom_out = 2.0;
X                    break;
X                case 4 : /* Center */
X                    cmd.command = center;
X                    cmd.data.pt.x = rect->x0;
X                    cmd.data.pt.y = rect->y0;
X                    deselect(g);
X                    break;
X                } break;
X
X            case 2 : switch (itemnb) { /* Add */
X                case 0 : /* Function */
X                    deselect(g);
X                    cmd.command = add_function;
X                    break;
X                case 1 : /* Label */
X                    cmd.command = add_label;
X                    cmd.data.pt.x = rect->x0;
X                    cmd.data.pt.y = rect->y0;
X                    deselect(g);
X                    break;
X                } break;
X
X            case 3 : switch (itemnb) { /* Edit */
X                case 0 : /* Variables */
X                    cmd.command = edit_vars;
X                    break;
X                case 2 : /* Select function */
X                    {   /* Processed locally */
X                        struct object *o;
X
X                        if (o = choose_object(g, "Select"))
X                        {
X                            deselect(g);
X                            select_object(g, o);
X                        }
X                    }
X                    break;
X                case 3 : /* Deselect */
X                    /* Processed locally */
X                    deselect(g);
X                    break;
X                case 5 : /* Edit */
X                    cmd.data.o = g->s.current;
X                    cmd.command = edit;
X                    break;
X                case 6 : /* Improve */
X                    cmd.data.f = g->s.current;
X                    cmd.command = improve;
X                    break;
X                case 7 : /* Delete */
X                    cmd.data.o = g->s.current;
X                    cmd.command = del_object;
X                    break;
X                } break;
X        }
X        *choice = item->NextSelect;
X        *choice = MENUNULL;
X    }
X    return cmd;
X}
X
X/* Return next command (in any graph) */
Xstruct cmd next_command(void)
X{
X    struct cmd cmd;
X    static int gone = FALSE;
X
X    cmd.command = none;
X
X    while (cmd.command == none) /* Wait for one */
X    {
X        struct graph *g;
X
X        /* Scan all graphs, checking for commands */
X        for (g = first(&graph_list); cmd.command == none && succ(g); g = succ(g
X))
X        {
X            int moved = FALSE;
X            struct IntuiMessage *msg;
X            WORD sx, sy;
X
X            cmd.g = g;
X            /* Any pending menu selections ? */
X            if (!req && g->io.nextmenu != MENUNULL) cmd = process(&g->io.nextme
Xnu, g);
X
X            /* Check for messages on window */
X            while (cmd.command == none && (msg = (struct IntuiMessage *)GetMsg(
Xg->io.win->UserPort)))
X            {
X                /* Save interesting info */
X                ULONG class = msg->Class;
X                UWORD code = msg->Code;
X                UWORD qualifier = msg->Qualifier;
X                struct Gadget *gg = (struct Gadget *)msg->IAddress, *gadg;
X
X                sx = msg->MouseX; sy = msg->MouseY;
X                ReplyMsg((struct Message *)msg);
X
X                if (class == MOUSEMOVE) /* Accumulate moves */
X                    moved = TRUE;
X                else
X                {
X                    if (moved) mouse_move(g, sx, sy); /* process any mouse move
Xment */
X                    moved = FALSE;
X                    /* Most messages imply that the mouse button is released. M
Xake sure that the program thinks so */
X                    if (class != MOUSEBUTTONS && class != REFRESHWINDOW) mouse_
Xup(g, sx, sy);
X
X                    switch (class)
X                    {
X                        /* Note that most messages are ignored while a
X                           requester is up in *any* window */
X
X                        case RAWKEY:
X                            /* Check for Amiga-V/B (Ok, Cancel shortcut) */
X                            if (req && (qualifier & AMIGALEFT) && (code == KEYC
XODE_V || code == KEYCODE_B))
X                            {
X                                ok = code == KEYCODE_V;
X                                /* Never let this happen while a string gadget
Xis active ... */
X                                EndRequest(req, req->RWindow);
X                            }
X                            break;
X                        case CLOSEWINDOW:
X                            if (!req) cmd.command = close;
X                            break;
X                        case MENUPICK:
X                            if (!req)
X                            {
X                                g->io.nextmenu = code;
X                                cmd = process(&g->io.nextmenu, g);
X                            }
X                            break;
X                        case REFRESHWINDOW:
X                            {
X                                int changed;
X
X                                /* Refresh partially only if size hasn't change
Xd */
X                                BeginRefresh(g->io.win);
X                                changed = g->io.win->Width != g->io.oldwidth ||
X g->io.win->Height != g->io.oldheight;
X                                if (!changed) draw_graph(g, FALSE); /* No messa
Xges during refresh !!! */
X                                EndRefresh(g->io.win, TRUE);
X                                if (changed)
X                                {
X                                    set_scale(g);
X                                    draw_graph(g, TRUE);
X                                }
X                                /* Wait for refresh after requester's disappear
Xance
X                                   before signaling it */
X                                if (gone)
X                                {
X                                    gone = FALSE;
X                                    cmd.command = reqgone;
X                                }
X                            }
X                            break;
X                        case REQSET: /* Activate first string gadget */
X                            gadg = NextText(req->ReqGadget);
X                            if (gadg && !reqdone) ActivateGadget(gadg, g->io.wi
Xn, req);
X                            break;
X                        case REQCLEAR:
X                            /* Allow 1 refresh before signaling this. There is
X                               probably a better way ! */
X                            gone = TRUE;
X                            break;
X                        case GADGETUP: case GADGETDOWN:
X                            /* Ack! Hack to avoid bug in string gadget activati
Xon (V1.2-1.3) */
X                            if (class == GADGETUP && (gg->GadgetType & STRGADGE
XT) != 0 && IntuitionBase->LibNode.lib_Version <= 34) IntuitionBase->ActiveGadget
X = NULL;
X
X                            /* Handle requester hgadgets */
X                            if (gadgethandler) ok = gadgethandler(gg, class, re
Xq, g);
X                            else if (gg->GadgetID == ARROW || gg->GadgetID == C
XROSS)
X                            {   /* Select new mode */
X                                MutualExclude(gg, g->io.gadgets, g->io.win);
X                                set_mode(g, gg->GadgetID == ARROW);
X                            }
X                            break;
X                        case MOUSEBUTTONS: /* Pass on to graph */
X                            if (code == SELECTDOWN)
X                                mouse_down(g, sx, sy);
X                            else
X                                mouse_up(g, sx, sy);
X                            break;
X                    }
X                }
X            }
X            /* Handle any pending moves */
X            if (moved) mouse_move(g, sx, sy);
X        }
X        /* Wait for something to happen */
X        if (cmd.command == none) Wait(window_sigs);
X    }
X    return cmd;
X}
X
X
X/* Enable/Disable various menus */
X
Xvoid disable_rect_menus(struct graph *g)
X{
X    struct Window *win = g->io.win;
X
X    OffMenu(win, SHIFTMENU(1) | SHIFTITEM(2) | SHIFTSUB(NOSUB)); /* Zoom */
X    OffMenu(win, SHIFTMENU(1) | SHIFTITEM(4) | SHIFTSUB(NOSUB)); /* Center */
X    OffMenu(win, SHIFTMENU(2) | SHIFTITEM(1) | SHIFTSUB(NOSUB)); /* Label */
X    OffMenu(win, SHIFTMENU(3) | SHIFTITEM(3) | SHIFTSUB(NOSUB)); /* Deselect */
X
X}
X
Xvoid enable_rect_menus(struct graph *g)
X{
X    struct Window *win = g->io.win;
X
X    OnMenu(win, SHIFTMENU(1) | SHIFTITEM(2) | SHIFTSUB(NOSUB)); /* Zoom */
X    OnMenu(win, SHIFTMENU(1) | SHIFTITEM(4) | SHIFTSUB(NOSUB)); /* Center */
X    OnMenu(win, SHIFTMENU(2) | SHIFTITEM(1) | SHIFTSUB(NOSUB)); /* Label */
X    OnMenu(win, SHIFTMENU(3) | SHIFTITEM(3) | SHIFTSUB(NOSUB)); /* Deselect */
X}
X
Xvoid disable_object_menus(struct graph *g)
X{
X    struct Window *win = g->io.win;
X
X    OffMenu(win, SHIFTMENU(3) | SHIFTITEM(3) | SHIFTSUB(NOSUB)); /* Deselect */
X
X    OffMenu(win, SHIFTMENU(3) | SHIFTITEM(5) | SHIFTSUB(NOSUB)); /* Edit */
X    OffMenu(win, SHIFTMENU(3) | SHIFTITEM(6) | SHIFTSUB(NOSUB)); /* Improve */
X    OffMenu(win, SHIFTMENU(3) | SHIFTITEM(7) | SHIFTSUB(NOSUB)); /* Delete */
X}
X
Xvoid enable_object_menus(struct graph *g)
X{
X    struct Window *win = g->io.win;
X
X    OnMenu(win, SHIFTMENU(3) | SHIFTITEM(3) | SHIFTSUB(NOSUB)); /* Deselect */
X    OnMenu(win, SHIFTMENU(3) | SHIFTITEM(5) | SHIFTSUB(NOSUB)); /* Edit */
X    OnMenu(win, SHIFTMENU(3) | SHIFTITEM(6) | SHIFTSUB(NOSUB)); /* Improve */
X    OnMenu(win, SHIFTMENU(3) | SHIFTITEM(7) | SHIFTSUB(NOSUB)); /* Delete */
X}
X
X/* Convert double to nice string (must be of size NBLEN) */
Xchar *double2str(char *to, double x)
X{
X    int l;
X
X    if (x == NOVAL) to[0] = '\0';
X    else sprintf(to, "%-5.3g", x);
X
X    l = strlen(to);
X    while (l > 0 && to[--l] == ' ') to[l] = '\0';
X
X    return to;
X}
X
X
X/* Convert string to double */
Xdouble str2double(char *from)
X{
X    double x;
X
X    if (sscanf(from, "%lf", &x) != 1) x = NOVAL;
X
X    return x;
X}
X
X/* convert x to a string (must be of size INTLEN) */
Xchar *int2str(char *to, int x)
X{
X    if (x == INOVAL) to[0] = '\0';
X    else sprintf(to, "%d", x);
X
X    return to;
X}
X
X/* convert string to integer */
Xint str2int(char *from)
X{
X    int x;
X
X    if (sscanf(from, "%d", &x) != 1) x = INOVAL;
X
X    return x;
X}
X
X/* Removes leading & trailing blanks fron name. Returns name */
Xchar *strip(char *name)
X{
X    char *scan = name;
X
X    while (isspace(*scan)) scan++;
X
X    if (*scan)
X    {
X        char *copy = name;
X
X        while (*scan) *(copy++) = *(scan++);
X
X        while (isspace(*--copy))
X            ;
X        *(copy + 1) = '\0';
X    }
X    else
X        *name = '\0';
X
X    return name;
X}
X
X/* Hack to allow you to press Amiga-V/B even while entering a string in a
X   string requester */
Xstatic long __saveds __asm handle_ok_cancel(register __a0 struct InputEvent *ev
X, register __a1 void *dummy)
X{
X    struct InputEvent *ep, *laste;
X    static struct InputEvent retkey;
X
X    if (req)
X        /* run down the list of events to see if they pressed the magic key */
X        for (ep = ev, laste = NULL; ep != NULL; ep = ep->ie_NextEvent)
X        {
X            if (ep->ie_Class == IECLASS_RAWKEY && (ep->ie_Qualifier & AMIGALEFT
X) && (ep->ie_Code == KEYCODE_V || ep->ie_Code == KEYCODE_B) && IntuitionBase->Ac
XtiveWindow == req->RWindow)
X            {
X                reqdone = TRUE; /* The requester is going away */
X                /* Add an extra "return key" event */
X                retkey.ie_Class = IECLASS_RAWKEY;
X                retkey.ie_SubClass = 0;
X                retkey.ie_Code = 0x44; /* return key */
X                retkey.ie_Qualifier = 0;
X                retkey.ie_position = ep->ie_position;
X                retkey.ie_TimeStamp = ep->ie_TimeStamp;
X                retkey.ie_NextEvent = ep;
X                /* we can handle this event so take it off the chain */
X                if (laste == NULL)
X                    ev = &retkey;
X                else
X                    laste->ie_NextEvent = &retkey;
X                break;
X            }
X            else
X                laste = ep;
X        }
X
X   /* pass on the pointer to the event */
X   return (long)ev;
X}
X
X/* Create window, menus for a new graph */
Xint init_uio(struct graph *g)
X{
X    /* Create mode select gadgets */
X    struct Gadget *a = AllocMem(sizeof(struct Gadget), 0L);
X    struct Gadget *c = AllocMem(sizeof(struct Gadget), 0L);
X
X    ModSys(0, 1, JAM2, &font);
X    if (a && c)
X    {
X        struct Menu *ml = NULL, *project, *edit, *add, *graph;
X        struct MenuItem *print;
X
X        *a = arrow;
X        *c = cross;
X        a->NextGadget = c;
X        g->io.gadgets = graph_win.FirstGadget = a;
X        g->io.mem = NULL;
X
X        /* Create window & menus */
X        if (g->io.win = OpenWindow(&graph_win))
X            if ((g->io.mem = NewMemory()) &&
X                (project = AddMenu(&ml, NULL, "Project", MENUENABLED, g->io.mem
X)) &&
X                    AddItem(project, "New Graph", ITEMENABLED | HIGHCOMP, 0, 'N
X', FALSE, g->io.mem) &&
X                    AddItem(project, "Delete Graph", ITEMENABLED | HIGHCOMP, 0,
X 0, FALSE, g->io.mem) &&
X                    AddItem(project, "Load Graph...", ITEMENABLED | HIGHCOMP, 0
X, 'O', FALSE, g->io.mem) &&
X                    AddItem(project, "Save Graph...", ITEMENABLED | HIGHCOMP, 0
X, 'S', FALSE, g->io.mem) &&
X                    (print = AddItem(project, "Output Graph", ITEMENABLED | HIG
XHCOMP, 0, 0, TRUE, g->io.mem)) &&
X                        AddSub(print, "To Printer", ITEMENABLED | HIGHCOMP, 0,
X'P', g->io.mem) &&
X                        AddSub(print, "To Disk...", ITEMENABLED | HIGHCOMP, 0,
X0, g->io.mem) &&
X                    AddRule(project, g->io.mem) &&
X                    AddItem(project, "Load Variables...", ITEMENABLED | HIGHCOM
XP, 0, 0, FALSE, g->io.mem) &&
X                    AddItem(project, "Save Variables...", ITEMENABLED | HIGHCOM
XP, 0, 0, FALSE, g->io.mem) &&
X                    AddRule(project, g->io.mem) &&
X                    AddItem(project, "Quit", ITEMENABLED | HIGHCOMP, 0, 'Q', FA
XLSE, g->io.mem) &&
X                (graph = AddMenu(&ml, NULL, "Graph", MENUENABLED, g->io.mem)) &
X&
X                    AddItem(graph, "Scale...", ITEMENABLED | HIGHCOMP, 0, 'L',
XFALSE, g->io.mem) &&
X                    AddItem(graph, "Axes...", ITEMENABLED | HIGHCOMP, 0, 'X', F
XALSE, g->io.mem) &&
X                    AddItem(graph, "Zoom", ITEMENABLED | HIGHCOMP, 0, 'Z', FALS
XE, g->io.mem) &&
X                    AddItem(graph, "Zoom out", ITEMENABLED | HIGHCOMP, 0, 0, FA
XLSE, g->io.mem) &&
X                    AddItem(graph, "Centre", ITEMENABLED | HIGHCOMP, 0, 'C', FA
XLSE, g->io.mem) &&
X                (add = AddMenu(&ml, NULL, "Add", MENUENABLED, g->io.mem)) &&
X                    AddItem(add, "Function...", ITEMENABLED | HIGHCOMP, 0, 'F',
X FALSE, g->io.mem) &&
X                    AddItem(add, "Label...", ITEMENABLED | HIGHCOMP, 0, 0, FALS
XE, g->io.mem) &&
X                (edit = AddMenu(&ml, NULL, "Edit", MENUENABLED, g->io.mem)) &&
X                    AddItem(edit, "Variables...", ITEMENABLED | HIGHCOMP, 0, 'V
X', FALSE, g->io.mem) &&
X                    AddRule(edit, g->io.mem) &&
X                    AddItem(edit, "Select function...", ITEMENABLED | HIGHCOMP,
X 0, 0, FALSE, g->io.mem) &&
X                    AddItem(edit, "Deselect", ITEMENABLED | HIGHCOMP, 0, 0, FAL
XSE, g->io.mem) &&
X                    AddRule(edit, g->io.mem) &&
X                    AddItem(edit, "Edit...", ITEMENABLED | HIGHCOMP, 0, 'E', FA
XLSE, g->io.mem) &&
X                    AddItem(edit, "Improve", ITEMENABLED | HIGHCOMP, 0, 'I', FA
XLSE, g->io.mem) &&
X                    AddItem(edit, "Delete", ITEMENABLED | HIGHCOMP, 0, 0, FALSE
X, g->io.mem))
X            {
X                SetMenuStrip(g->io.win, ml);
X                g->io.menu = ml;
X                disable_rect_menus(g);
X                disable_object_menus(g);
X                /* Add signal bit */
X                window_sigs |= 1 << g->io.win->UserPort->mp_SigBit;
X
X                return TRUE; /* all done ok */
X            }
X            else
X            {
X                Free(g->io.mem);
X                CloseWindow(g->io.win);
X                alert(NULL, "No memory !", NULL);
X            }
X        else alert(NULL, "Couldn't open window", NULL);
X    }
X    else
X        alert(NULL, "No memory !", NULL);
X
X    if (a) FreeMem(a, sizeof(struct Gadget));
X    if (c) FreeMem(c, sizeof(struct Gadget));
X
X    return FALSE;
X}
X
X/* Close window, etc */
Xvoid cleanup_uio(struct graph *g)
X{
X    struct Gadget *gg, *next;
X
X    ClearMenuStrip(g->io.win);
X    CloseWindow(g->io.win);
X    Free(g->io.mem);
X    for (gg = g->io.gadgets; gg; gg = next)
X    {
X        next = gg->NextGadget;
X        FreeMem(gg, sizeof(struct Gadget));
X    }
X    /* Construct new signal list */
X    window_sigs = 0;
X    for (g = first(&graph_list); succ(g); g = succ(g))
X        window_sigs |= 1 << g->io.win->UserPort->mp_SigBit;
X}
X
X/* Global initialisation */
Xint init_user()
X{
X    if (!make_font_list()) return FALSE;
X    /* Open alert font */
X    alert_font = OpenFont(&alert_attr);
X
X    /* Install input handler */
X    me = FindTask(0);
X    inputDevPort = CreatePort(0,0);
X    if (inputDevPort)
X    {
X        if (inputRequestBlock = CreateStdIO(inputDevPort))
X        {
X
X            handlerStuff.is_Data = NULL;
X            handlerStuff.is_Code = (void *)handle_ok_cancel;
X            handlerStuff.is_Node.ln_Pri = 51;
X
X            if (OpenDevice("input.device", 0, inputRequestBlock, 0) == 0)
X            {
X                inputOpen = TRUE;
X                inputRequestBlock->io_Command = IND_ADDHANDLER;
X                inputRequestBlock->io_Data    = (APTR)&handlerStuff;
X
X                DoIO(inputRequestBlock);
X                return TRUE;
X            }
X        }
X    }
X    alert(NULL, "Couldn't install input handler", NULL);
X    return FALSE;
X}
X
X/* Global cleanup */
Xvoid cleanup_user()
X{
X    if (inputOpen)
X    {
X        inputRequestBlock->io_Command = IND_REMHANDLER;
X        inputRequestBlock->io_Data    = (APTR)&handlerStuff;
X        DoIO(inputRequestBlock);
X        CloseDevice(inputRequestBlock);
X    }
X    if (inputRequestBlock) DeleteStdIO(inputRequestBlock);
X    if (inputDevPort) DeletePort(inputDevPort);
X    free_list((list *)&flist, sizeof(struct fnode));
X}
X
SHAR_EOF
echo "extracting uio.h"
sed 's/^X//' << \SHAR_EOF > uio.h
X/*
X *                 GRAPH, Version 1.00 - 4 August 1989
X *
X *            Copyright 1989, David Gay. All Rights Reserved.
X *            This software is freely redistrubatable.
X */
X
X/* User interface routines (windows, menus, requesters, etc) */
X#ifndef UIO_H
X#define UIO_H
X
X#include "list.h"
X
X#define FONTLEN 30 /* font name length */
X#define NBLEN 25
X#define INTLEN 11
X
X/* A gadget handler routine, called for every gadget event when a requester is
Xpresent */
Xtypedef int gadgevent(struct Gadget *gadg, ULONG class, struct Requester *req,
Xstruct graph *g);
X
X/* All possible commands */
Xenum commands {none, reqgone, /* internal */
X               close, /* window closed */
X               /* menu functions */
X               _new_graph, _load_graph, _save_graph, print_graph, iff_graph, lo
Xad_vars, save_vars, quit,
X               limits, axes, zoom, zoom_out, center,
X               add_function, add_label,
X               edit, improve, del_object, edit_vars
X              };
X
X/* Description of selected command, union depends on command */
Xstruct cmd {
X    enum commands command;
X    struct graph *g;
X    union {
X        struct function *f;
X        struct object *o;
X        double zoom_out;
X        struct {
X            double x0, y0, x1, y1;
X        } zoom_in;
X        struct {
X            double x, y;
X        } pt;
X    } data;
X};
X
Xextern tlist flist;                 /* List of available font names */
X
Xint make_font_list(void);           /* (Re)make flist */
Xchar *addfont(char *fname);         /* Add/Remove ".font" from font names */
Xchar *remfont(char *fname);
X
X/* Display requester(in graph g), wait for it to leave */
X/* handle will be called for every gadget event */
Xint DoRequest(struct Requester *r, struct graph *g, gadgevent *handle);
X/* The default gadget handler (switches between text gadgets) */
Xint std_ghandler(struct Gadget *gg, ULONG class, struct Requester *req, struct
Xgraph *g);
Xint getfile(char *file, char *msg);                          /* File requester
X*/
Xstruct Requester *abort_request(struct graph *g, char *msg); /* Setup an abort
Xrequester */
Xvoid set_abort_msg(struct Requester *req, char *msg);        /* Change abort ms
Xg */
Xvoid end_abort_request(struct Requester *req);               /* Clear abort req
X */
Xint aborted(struct Requester *req);                          /* Did user abort
X? */
Xvoid message(struct graph *g, ...);                          /* Display a messa
Xge (in a graph) */
Xvoid alert(struct Window *win, char *msg1, char *msg2);      /* Use when no gra
Xph available */
Xvoid nomem(struct Window *win);                              /* Standard no mem
Xory alert */
X
Xstruct cmd next_command(void);      /* Return next selected command */
X
X/* String utility functions, convert numbers to strings */
Xchar *double2str(char *to, double x);
Xdouble str2double(char *from);
Xchar *int2str(char *to, int x);
Xint str2int(char *from);
Xchar *strip(char *name);            /* Strip leading & trailing blanks */
X
X/* Enable/Disable various menus */
Xvoid disable_rect_menus(struct graph *g);   /* Menus for 'pos' object */
Xvoid enable_rect_menus(struct graph *g);
Xvoid disable_object_menus(struct graph *g); /* For selected objects */
Xvoid enable_object_menus(struct graph *g);
X
Xint init_user(void);
Xvoid cleanup_user(void);
Xint init_uio(struct graph *g);      /* Setup/Cleanup interface for each graph *
X/
Xvoid cleanup_uio(struct graph *g);
X
X#endif
X
SHAR_EOF
echo "extracting x_y.c"
sed 's/^X//' << \SHAR_EOF > x_y.c
X/*
X *                 GRAPH, Version 1.00 - 4 August 1989
X *
X *            Copyright 1989, David Gay. All Rights Reserved.
X *            This software is freely redistrubatable.
X */
X
X#include <exec/types.h>
X#include <intuition/intuition.h>
X#include <graphics/text.h>
X#include <math.h>
X#include <string.h>
X
X#include "object.h"
X#include "object/function.h"
X#include "file.h"
X#include "graph.h"
X#include "uio.h"
X#include "coords.h"
X#include "list.h"
X#include "grph.h"
X#include "user/eval.h"
X#include "user/gadgets.h"
X#include "tracker.h"
X
X#include <proto/exec.h>
X#include <proto/intuition.h>
X#include <proto/graphics.h>
X
Xstruct x_y {
X    struct function f;
X    char x[EXPRLEN], y[EXPRLEN];
X    value x_t, y_t, dx, dy;
X};
X
Xstruct point_x_y {
X    point p;
X    double t;
X};
X
Xtypedef struct point_x_y point_x_y;
X
X/*-------------------------------------------------------------------------*/
X/*                        x_y class implementation                         */
X/*-------------------------------------------------------------------------*/
X
X/* Is the function displayable ? */
Xstatic int x_y_ok(const struct x_y *this)
X{
X    return this->f.min != NOVAL && this->f.max != NOVAL &&
X           this->f.min < this->f.max &&
X           (this->f.steps == INOVAL || this->f.steps >= 3);
X}
X
X/* Free resources */
Xstatic void destroy_x_y(struct x_y *this)
X{
X    free_var_list(&this->f.used);
X    if (this->f.calc) free_list(&this->f.pts, this->f.sizept);
X    this->f.calc = FALSE;
X    if (this->x_t) free_expr(this->x_t);
X    if (this->dx) free_expr(this->dx);
X    if (this->y_t) free_expr(this->y_t);
X    if (this->dy) free_expr(this->dy);
X    this->dx = this->dy = this->x_t = this->y_t = NULL;
X}
X
X/* Init dependant parts of function */
Xstatic int create_x_y(struct x_y *this)
X{
X    this->f.calc = FALSE;
X    this->f.var.name = this->f.vname;
X    this->x_t = compile(this->x);
X    if (eval_error != 0)
X    {
X        message(this->f.o.g, "Compilation error in x(t):", eval_messages[eval_e
Xrror], (char *)NULL);
X        return FALSE;
X    }
X    this->dx = differentiate(this->x_t, this->f.vname);
X    if (eval_error != NOT_DIFFERENTIABLE && eval_error != 0)
X    {
X        message(this->f.o.g, "Differentiation error (x):", eval_messages[eval_e
Xrror], (char *)NULL);
X        return FALSE;
X    }
X    this->y_t = compile(this->y);
X    if (eval_error != 0)
X    {
X        message(this->f.o.g, "Compilation error in y(t):", eval_messages[eval_e
Xrror], (char *)NULL);
X        return FALSE;
X    }
X    this->dy = differentiate(this->y_t, this->f.vname);
X    if (eval_error != NOT_DIFFERENTIABLE && eval_error != 0)
X    {
X        message(this->f.o.g, "Differentiation error(y):", eval_messages[eval_er
Xror], (char *)NULL);
X        return FALSE;
X    }
X    if (!make_var_list(this->x_t, &this->f.used) || !make_var_list(this->y_t, &
Xthis->f.used))
X        init_var_list(&this->f.used);
X    return TRUE;
X}
X
X/* Allow user to define function */
Xstatic int edit_x_y(struct x_y *this, struct Region **ref)
X{
X    struct Requester *req;
X    struct Memory *m;
X    struct Gadget *gl = NULL, *sd, *nd;
X    char from[NBLEN], to[NBLEN], steps[INTLEN], x[EXPRLEN], y[EXPRLEN], tname[V
XARLEN], colour[INTLEN];
X    int ret = FALSE;
X
X    *ref = NULL;
X
X    /* Create requester */
X    double2str(from, this->f.min);
X    double2str(to, this->f.max);
X    int2str(steps, this->f.steps);
X    int2str(colour, this->f.colour);
X    strcpy(x, this->x);
X    strcpy(y, this->y);
X    strcpy(tname, this->f.vname);
X
X    if ((m = NewMemory()) &&
X        (req = InitReq(50, 20, 255, 165, m)) &&
X        SetReqBorder(req, 1, m) &&
X        AddIntuiText(&req->ReqText, "Function", 95, 6, m) &&
X        AddText(&gl, 0, "x(", FALSE, tname, VARLEN, TRUE, 0, RELVERIFY, 25, 20,
X 24, 10, TRUE, m) &&
X        AddText(&gl, 0, ")=", FALSE, x, EXPRLEN, TRUE, 0, RELVERIFY, 81, 20, 16
X0, 10, TRUE, m) &&
X        AddText(&gl, 0, "y(   )=", FALSE, y, EXPRLEN, TRUE, 0, RELVERIFY, 81, 4
X0, 160, 10, TRUE, m) &&
X        AddText(&gl, 0, "from ", FALSE, from, NBLEN, TRUE, 0, RELVERIFY, 49, 60
X, 80, 10, TRUE, m) &&
X        AddText(&gl, 0, "to ", FALSE, to, NBLEN, TRUE, 0, RELVERIFY, 167, 60, 8
X0, 10, TRUE, m) &&
X        AddText(&gl, 0, "steps ", FALSE, steps, INTLEN, TRUE, 0, RELVERIFY, 57,
X 80, 32, 10, TRUE, m) &&
X        AddText(&gl, 0, "colour ", FALSE, colour, INTLEN, TRUE, 0, RELVERIFY, 1
X56, 80, 32, 10, TRUE, m) &&
X        (sd = AddOption(&gl, 0, "Show discontinuities", TRUE, this->f.showdisc
X* SELECTED, 0, 9, 100, 10, 10, m)) &&
X        (nd = AddOption(&gl, 0, "Allow flat discontinuities", TRUE, this->f.nic
Xedisc * SELECTED, 0, 9, 120, 10, 10, m)) &&
X        AddBox(&gl, TRUE, "Ok", 0, RELVERIFY | ENDGADGET, 40, 140, 65, 15, FALS
XE, m) &&
X        AddBox(&gl, FALSE, "Cancel", 0, RELVERIFY | ENDGADGET, 145, 140, 65, 15
X, FALSE, m))
X    {
X        SetReqGadgets(req, gl);
X        if (ret = DoRequest(req, this->f.o.g, std_ghandler))
X        {
X            *ref = full_refresh(this->f.o.g);
X
X            /* Extract info */
X            this->f.min = str2double(from);
X            this->f.max = str2double(to);
X            this->f.steps = str2int(steps);
X            if ((this->f.colour = str2int(colour)) == INOVAL) this->f.colour =
X1;
X            this->f.showdisc = (sd->Flags & SELECTED) != 0;
X            this->f.nicedisc = (nd->Flags & SELECTED) != 0;
X            strcpy(this->x, x);
X            strcpy(this->y, y);
X            strcpy(this->f.vname, tname);
X
X            /* Create function */
X            destroy_x_y(this);
X            if (this->f.o.ok = x_y_ok(this)) this->f.o.ok = create_x_y(this);
X        }
X    }
X    Free(m);
X
X    return ret;
X}
X
X/* Calculate points of function */
Xstatic int calc_x_y(struct x_y *this, int allow_mes)
X{
X    double t;
X    int i;
X    struct graph *const g = this->f.o.g;
X    double const tmin = this->f.min;
X    double const tmax = this->f.max;
X    int const steps = this->f.steps == INOVAL ? DEFSTEPS : this->f.steps;
X    double const step = (tmax - tmin) / (steps - 1);
X    static char func[FNAMELEN + 30];
X
X    strcpy(func, "Can't calculate points for ");
X    strcat(func, this->f.o.name);
X    strcat(func, ":");
X
X    new_list(&this->f.pts);
X
X    if (!create_quick(&this->f.var))
X    {
X        if (allow_mes) message(g, func, "Couldn't create variable", (char *)NUL
XL);
X        else alert(g->io.win, func, "Couldn't create variable");
X        return FALSE;
X    }
X
X    /* Calculate steps points, spread evenly from min to max */
X    for (i = 0, t = tmin; i < steps; i++, t += step)
X    {
X        point_x_y *pt = alloc_node(this->f.sizept);
X
X        if (!pt)
X        { /* No mem */
X            free_list(&this->f.pts, this->f.sizept);
X            free_quick(&this->f.var);
X            if (allow_mes) message(g, func, "No memory", (char *)NULL);
X            else alert(g->io.win, func, "No memory");
X            return FALSE;
X        }
X        add_tail(&this->f.pts, pt);
X
X        set_quick(&this->f.var, t);
X        pt->t = t;
X
X        pt->p.x = quick_eval(this->x_t);
X        pt->p.state = (eval_error == 0) ? EXISTS : 0;
X        if (pt->p.state == EXISTS)
X        {
X            pt->p.y = quick_eval(this->y_t);
X            pt->p.state = (eval_error == 0) ? EXISTS : 0;
X        }
X    }
X    free_quick(&this->f.var);
X    return TRUE;
X}
X
X/* Try to improve look of function by adding points. If fails, decides that
X   there is a discontinuity */
X/* see f_of_x.c for details */
Xstatic int improve_x_y(struct x_y *this)
X{
X    struct graph *const g = this->f.o.g;
X    point_x_y *pt, *next;
X    int ok = FALSE, iter, abort = FALSE;
X    double flatx = FLAT * (g->a.y.max - g->a.y.min) / g->io.win->Height;
X    double flaty = FLAT * (g->a.x.max - g->a.x.min) / g->io.win->Width;
X    char msg[FNAMELEN + 30];
X    char pass[20];
X    struct Requester *req;
X    struct Region *full = NULL;
X
X    /* Flat has no meaning when graph incorrect */
X    if (!this->f.o.g->ok) flatx = flaty = 0.0;
X
X    if (!this->f.calc)
X    {
X        strcpy(msg, this->f.o.name);
X        strcpy(msg, "not calculated!");
X        message(g, msg, (char *)NULL);
X        return NULL;
X    }
X    if (!this->dx || !this->dy)
X    {
X        strcpy(msg, this->f.o.name);
X        strcat(msg, " wasn't differentiable");
X        message(g, msg, (char *)NULL);
X        return NULL;
X    }
X    if (!create_quick(&this->f.var))
X    {
X        message(g, "Couldn't create variable", (char *)NULL);
X        return NULL;
X    }
X
X    if (!(req = abort_request(g, "Improve: Pass 1")))
X        message(g, "No Memory !", (char *)NULL);
X    else
X    {
X        full = full_refresh(this->f.o.g);
X
X        for (iter = 1; iter <= MAXITER && !ok && !abort; iter++)
X        {
X            sprintf(pass, "Improve: Pass %d", iter);
X            set_abort_msg(req, pass);
X            ok = TRUE;
X
X            for (pt = first(&this->f.pts); succ(next = succ(pt)); pt = next)
X            {
X                if ((pt->p.state & (EXISTS | OK)) == EXISTS) /* Only exists */
X                {
X                    double dx, dy;
X
X                    pt->p.state |= OK;
X                    pt->p.state &= ~DISC;
X
X                    set_quick(&this->f.var, pt->t);
X                    dx = quick_eval(this->dx);
X                    if (eval_error == 0)
X                    {
X                        dy = quick_eval(this->dy);
X                        if (eval_error == 0)
X                        {
X                            double ecartx = next->p.x - pt->p.x;
X                            double errorx = fabs(ecartx - (next->t - pt->t) * d
Xx);
X                            double ecarty = next->p.y - pt->p.y;
X                            double errory = fabs(ecarty - (next->t - pt->t) * d
Xy);
X
X                            /* Check both axes */
X                            if ((errorx > fabs(ecartx) * MAXERROR && (!this->f.
Xnicedisc || errorx > flatx)) ||
X                                (errory > fabs(ecarty) * MAXERROR && (!this->f.
Xnicedisc || errory > flaty)))
X                            {
X                                pt->p.state &= ~OK;
X                                ok = FALSE;
X
X                                if (iter == MAXITER) pt->p.state |= DISC;
X                                else /* cut interval in 2 */
X                                {
X                                    point_x_y *newpt = alloc_node(this->f.sizep
Xt);
X
X                                    if (!newpt)
X                                    {
X                                        nomem(g->io.win);
X                                        abort = TRUE;
X                                        break;
X                                    }
X
X                                    newpt->t = (pt->t + next->t) / 2;
X                                    set_quick(&this->f.var, newpt->t);
X                                    newpt->p.x = quick_eval(this->x_t);
X                                    newpt->p.state = (eval_error == 0) ? EXISTS
X : 0;
X                                    if (newpt->p.state == EXISTS)
X                                    {
X                                        newpt->p.y = quick_eval(this->y_t);
X                                        newpt->p.state = (eval_error == 0) ? EX
XISTS : 0;
X                                    }
X                                    insert(&this->f.pts, newpt, pt);
X                                }
X                            }
X                        }
X                    }
X                }
X            }
X        }
X        end_abort_request(req);
X    }
X    free_quick(&this->f.var);
X    return full;
X}
X
X/* String representation of function */
Xstatic char *f2str_x_y(struct x_y *this, char *buf, int maxlen)
X{
X    buf[maxlen - 1] = '\0';
X    strncpy(buf, this->f.o.name, maxlen - 1);
X    strncat(buf, ": x(", maxlen - strlen(buf) - 1);
X    strncat(buf, this->f.vname, maxlen - strlen(buf) - 1);
X    strncat(buf, ")=", maxlen - strlen(buf) - 1);
X    strncat(buf, this->x, maxlen - strlen(buf) - 1);
X    strncat(buf, ", y(", maxlen - strlen(buf) - 1);
X    strncat(buf, this->f.vname, maxlen - strlen(buf) - 1);
X    strncat(buf, ")=", maxlen - strlen(buf) - 1);
X    strncat(buf, this->y, maxlen - strlen(buf) - 1);
X
X    return buf;
X}
X
X/* Save local data to file */
Xstatic int save_x_y(struct x_y *this, FILE *f)
X{
X    short tag = X_Y_TAG;
X    short end = X_Y_END;
X
X    return WRITE(f, tag) &&
X           WRITE(f, this->x) &&
X           WRITE(f, this->y) &&
X           WRITE(f, end);
X}
X
X/* free function */
Xstatic struct Region *delete_x_y(struct x_y *this)
X{
X    struct Region *full = full_refresh(this->f.o.g);
X
X    destroy_x_y(this);
X    FreeMem(this, sizeof(struct x_y));
X
X    return full;
X}
X
X/* Create a new function */
Xstruct x_y *new_x_y(struct graph *g, char *name)
X{
X    struct x_y *this = AllocMem(sizeof(struct x_y), MEMF_CLEAR);
X
X    if (this)
X    {
X        /* Standard init */
X        init_function(&this->f, g, name);
X        /* Local methods */
X        this->f.o.delete = (void *)delete_x_y;
X        this->f.o.edit = (void *)edit_x_y;
X        this->f.o.improve = (void *)improve_x_y;
X        this->f.o.f2str = (void *)f2str_x_y;
X        this->f.calcf = (void *)calc_x_y;
X        this->f.save = (void *)save_x_y;
X        this->f.sizept = sizeof(point_x_y);
X        return this;
X    }
X    message(g, "Couldn't create function:", "No memory", (char *)NULL);
X    return NULL;
X}
X
X/* load from file */
Xstruct x_y *load_x_y(struct graph *g, FILE *f)
X{
X    struct x_y *this = new_x_y(g, "");
X
X    if (this)
X    {
X        short end;
X
X        /* Read local data */
X        if (READ(f, this->x) &&
X            READ(f, this->y) &&
X            READ(f, end) &&
X            end == X_Y_END)
X        {
X            load_rest(&this->f, f); /* Read standard data */
X            if (this->f.o.ok = x_y_ok(this)) this->f.o.ok = create_x_y(this);
X
X            return this;
X        }
X        delete_x_y(this);
X    }
X    return NULL;
X}
X
SHAR_EOF
echo "End of archive 7 (of 7)"
# if you want to concatenate archives, remove anything after this line
exit